java对象实现Serializable接口 - CSDN博客

创建时间：2017/12/15 14:55
来源：http://blog.csdn.net/u013250327/article/details/39023143


java对象实现Serializable接口
java对象实现Serializable接口
在还没有深入了解serializable接口之前，像很多程序员一样，以为一个对象实现serializable接口就被序列化了。
最近在接触ehcache缓存的时候，将对象缓存起来，该对象需要先实现Serializable接口，然而，我们会发现对象并没有真正的被序列化。
下面让我们一起来总结一下Serializable接口的实现原理。
当一个类实现了Seializable接口（该接口仅为标记接口，不包含任何方法定义），表示该类可以序列化，序列化的目的是将一个实现了Serializable接口的对象可以转换成一个字节序列，保存对象的状态。
把该字节序列保存起来（例如：保存在一个文件里），以后可以随时将该字节序列恢复为原来的对象。甚至可以将该字节序列放到其他计算机上或者通过网络传输到其他计算机上恢复，只有该计算机平台存在相应的类就可以正常恢复为原来的对象。
一个对象实现Serializable接口序列化，先要创建某些OutputStream对象，然后将其封装在一个ObjectOutputStream对象内，再调用writeObject（）方法，即可序列化一个对象，反序列化，InputStream，再调用readObject（）方法。（writeObject和readObject本身就是线程安全的，传输过程中是不允许被并发访问的，所以对象只能一个一个接连不断的传过来）。
如果某个类能够被序列化，其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态，transient代表对象的临时数据，static对象变量在反序列化时取得的值为当前jvm中对应类中对应static变量的值，而transient（瞬态）关键字则一般用于标识那些在序列化时不需要传递的状态变量。
Person类
  1. package org.test.domain;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class Person implements Serializable{  
  6.   
  7.     /** 
  8.      *  
  9.      */  
  10.     private static final long serialVersionUID = 1L;  
  11.       
  12.     protected String name;  
  13.     protected transient int age;  
  14.       
  15.       
  16.     public Person(){}  
  17.       
  18.     public Person(String name,int age){  
  19.         this.name = name;  
  20.         this.age = age;       
  21.     }  
  22.       
  23.     public String getName() {  
  24.         return name;  
  25.     }  
  26.     public void setName(String name) {  
  27.         this.name = name;  
  28.     }  
  29.   
  30.     public int getAge() {  
  31.         return age;  
  32.     }  
  33.     public void setAge(int age) {  
  34.         this.age = age;  
  35.     }  
  36.       
  37.     public String toString()  
  38.     {  
  39.         return "this is person:"+"name:"+this.name+"——age:"+this.age;  
  40.     }  
  41. }  

User类
  1. package org.test.domain;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class User extends Person{  
  6.   
  7.     /** 
  8.      *  
  9.      */  
  10.     private static final long serialVersionUID = 1L;  
  11.       
  12.     private String name;  
  13.     private String password;  
  14.       
  15.     public User() {  
  16.           
  17.     }  
  18.   
  19.     public User(String name,String password,int age)  
  20.     {  
  21.         this.name = name;  
  22.         this.password = password;  
  23.         this.age = age;  
  24.     }  
  25.       
  26.     public String getName() {  
  27.         return name;  
  28.     }  
  29.   
  30.     public void setName(String name) {  
  31.         this.name = name;  
  32.     }  
  33.   
  34.     public String getPassword() {  
  35.         return password;  
  36.     }  
  37.   
  38.     public void setPassword(String password) {  
  39.         this.password = password;  
  40.     }  
  41.   
  42.     public String toString()  
  43.     {  
  44.         return "this is user:"+"name:"+this.name+"——password:"+this.password+"——age:"+this.age;  
  45.     }  
  46.       
  47. }  

SerializableTest类
  1. package org.test.main;  
  2.   
  3. import java.io.ByteArrayInputStream;  
  4. import java.io.ByteArrayOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8.   
  9. import org.test.domain.Person;  
  10. import org.test.domain.User;  
  11.   
  12. public class SerializableTest {  
  13.   
  14.     public static void main(String[] args) {  
  15.           
  16.         Person p1 = (Person)deSerialByte(serialByte(new User("user","1234",15)));  
  17.           
  18.         //Person p2 = (Person)deSerialByte(serialByte(new Person("person",10)));  
  19.           
  20.         System.out.println("p1:"+p1.toString());  
  21.           
  22.         //System.out.println("p2:"+p2.toString());  
  23.     }  
  24.       
  25.     //序列化一个对象（可以存储到一个文件也可以存储到字节数组）这里存储到自己数组  
  26.     public static byte[] serialByte(Object obj)  
  27.     {  
  28.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  29.         ObjectOutputStream oos;  
  30.         try {  
  31.             oos = new ObjectOutputStream(baos);  
  32.             oos.writeObject(obj);  
  33.             oos.close();  
  34.             return baos.toByteArray();  
  35.         } catch (IOException e) {  
  36.             throw new RuntimeException(e.getMessage());  
  37.         }  
  38.     }  
  39.       
  40.     //反序列化一个对象  
  41.     public static Object deSerialByte(byte[] by)  
  42.     {  
  43.         ObjectInputStream ois;  
  44.         try {  
  45.             ois = new ObjectInputStream(new ByteArrayInputStream(by));  
  46.             return ois.readObject();  
  47.         } catch (Exception e) {  
  48.             throw new RuntimeException(e.getMessage());  
  49.         }  
  50.     }  
  51. }  

serialVersionUID作用： 
       序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
有两种生成方式：
       一个是默认的1L，比如：private static final long serialVersionUID = 1L;
       一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：
       private static final   long     serialVersionUID = xxxxL;

当你一个类实现了Serializable接口，如果没有定义serialVersionUID，Eclipse会提供这个提示功能告诉你去定义 。在Eclipse中点击类中warning的图标一下，Eclipse就会自动给定两种生成的方式。如果不想定义它，在Eclipse的设置中也
       可以把它关掉的，设置如下： 
        Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==>
        Potential programming problems 
        将Serializable class without serialVersionUID的warning改成ignore即可。

如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable这个接口的话，如果没有加入serialVersionUID，Eclipse都会给你warning提示，这个serialVersionUID为了让该类别Serializable向后兼容。

如果你的类Serialized存到硬盘上面后，可是后来你却更改了类别的field(增加或减少或改名)，当你Deserialize时，就会出现Exception的，这样就会造成不兼容性的问题。

但当serialVersionUID相同时，它就会将不一样的field以type的预设值Deserialize，可避开不兼容性问题。


注意以下几点：

1、若继承的父类没有实现Serializable接口，但是又想让子类可序列化，子类实现Serializable接口，子类必须有可访问的无参构造方法，用于保存和恢复父类的public或protected或同包下的package字段的状态，否则在序列化或反序列化时会抛出RuntimeException异常，对于序列化后的子类，在进行反序列化时，理论上无法初始化父类中private（不可访问）对象变量的状态或值。

2、在对可序列化类中的属性进行序列化时，如果遇到不可序列化的对象变量，此时会针对不可序列化的类抛出NotSerializableException异常

3、对于可序列化的非数组类，强烈建议显示声明static型、long型、final型serialVersionUID字段用于标识当前序列化类的版本号，否则在跨操作系统、跨编译器之间进行序列化和反序列化时容易出现InvalidClassException异常